/**
 * 从路由配置生成权限树
 */
import type { RouteRecordRaw } from 'vue-router'
import type { PermissionTreeNode } from '@/types/permission'

export interface RouteAction {
  title: string
  code: string
}

/**
 * 从路由配置生成权限树
 * @param routes 路由配置
 * @param currentUserRole 当前用户角色，用于过滤模块级权限
 * @returns 权限树节点数组
 */
export function generatePermissionTree(routes: RouteRecordRaw[], currentUserRole?: string): PermissionTreeNode[] {
  const tree: PermissionTreeNode[] = []

  const processRoute = (route: RouteRecordRaw): PermissionTreeNode | null => {
    const meta = route.meta as any

    // 跳过隐藏的菜单项
    if (meta?.hideInMenu) {
      return null
    }

    // 权限树只显示当前用户角色可能分配的权限
    // 如果路由配置了角色限制，其他角色用户不应该看到这些权限

    // 如果是模块
    if (meta?.isModule && route.children && route.children.length > 0) {
      // 模块级别需要检查角色权限
      if (currentUserRole && meta?.roles && meta.roles.length > 0 && !meta.roles.includes(currentUserRole)) {
        return null // 当前用户角色无法访问此模块
      }

      // 支持新的对象格式 { title, code } 和旧的字符串格式
      const modulePerm = meta.permission;
      const modulePermCode = typeof modulePerm === 'string' ? modulePerm : modulePerm?.code;
      const moduleNode: PermissionTreeNode = {
        key: modulePermCode || meta.moduleKey || route.path,
        title: meta.title || '',
        permissionCode: (modulePermCode || meta.moduleKey || route.path) as string,
        permissionType: 'MENU',
        children: [],
      }

      // 处理模块下的子路由
      route.children.forEach((child) => {
        const childNode = processRoute(child)
        if (childNode) {
          moduleNode.children!.push(childNode)
        }
      })

      // 只返回有子节点的模块
      if (moduleNode.children && moduleNode.children.length > 0) {
        return moduleNode
      }
      return null
    }

    // 如果有 permission 字段，说明是一个菜单项
    if (meta?.permission) {
      // 功能级别也需要检查角色权限
      if (currentUserRole && meta?.roles && meta.roles.length > 0 && !meta.roles.includes(currentUserRole)) {
        return null // 当前用户角色无法访问此功能
      }

      // 支持新的对象格式 { title, code } 和旧的字符串格式
      const perm = meta.permission;
      const permCode = typeof perm === 'string' ? perm : perm.code;
      const permTitle = typeof perm === 'string' ? (meta.title || '') : perm.title;

      // 创建父节点（页面权限和按钮权限的容器）
      const parentNode: PermissionTreeNode = {
        key: permCode,
        title: meta.title || '',
        permissionCode: permCode,
        permissionType: 'MENU',
        children: [],
      }

      // 添加页面权限作为第一个子节点（与按钮权限同一层级）
      // 使用 page_ 前缀作为页面权限的权限码，与后端保持一致
      const pagePermissionCode = `page_${permCode}`;
      parentNode.children!.push({
        key: pagePermissionCode as any,
        title: permTitle,
        permissionCode: pagePermissionCode,
        permissionType: 'MENU',
      })

      // 添加按钮权限
      if (meta.$actions) {
        Object.values(meta.$actions as Record<string, RouteAction>).forEach((action) => {
          parentNode.children!.push({
            key: action.code as any,
            title: action.title,
            permissionCode: action.code,
            permissionType: 'BUTTON',
          })
        })
      }

      return parentNode
    }

    return null
  }

  routes.forEach((route) => {
    const node = processRoute(route)
    if (node) {
      tree.push(node)
    }
  })

  return tree
}

/**
 * 从路由配置提取所有权限代码
 * @param routes 路由配置
 * @returns 权限代码数组
 */
export function extractAllPermissions(routes: RouteRecordRaw[]): string[] {
  const permissions: string[] = []

  const processRoute = (route: RouteRecordRaw) => {
    const meta = route.meta as any

    // 跳过隐藏的菜单项
    if (meta?.hideInMenu) {
      return
    }

    // 添加菜单权限
    if (meta?.permission) {
      // 支持新的对象格式 { title, code } 和旧的字符串格式
      const permCode = typeof meta.permission === 'string' ? meta.permission : meta.permission.code;
      if (permCode) permissions.push(permCode);
    }

    // 添加按钮权限
    if (meta?.$actions) {
      Object.values(meta.$actions as Record<string, RouteAction>).forEach((action) => {
        permissions.push(action.code)
      })
    }

    // 递归处理子路由
    if (route.children && route.children.length > 0) {
      route.children.forEach((child) => {
        processRoute(child)
      })
    }
  }

  routes.forEach((route) => {
    processRoute(route)
  })

  return permissions
}

